package com.liuhousemyjavabasic.ArrayDo;

import org.junit.Test;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Random;

//https://www.w3cschool.cn/java/java-array.html

public class Array01 {
    //数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
    //Java 语言中提供的数组是用来存储固定大小的同类型元素。
    //你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。
    //本教程将为大家介绍Java数组的声明、创建和初始化，并给出其对应的代码。

    @Test
    public void testIntArray(){
        //开辟了一个长度为3的数组
        int data[] = new int[3];
        data[0] = 10;//第一个元素
        data[1] = 20;//第二个元素
        data[2] = 30;//第三个元素
        for(int x = 0 ; x < data.length ; x++){
            System.out.println(data[x]);
        }
    }


    @Test
    public void testIntArray01(){
        //采用分布的模式开辟数组空间
        int data[] = null;
        data = new int[3];//开辟了一个长度为3的数组
        data[0] = 10;//第一个元素
        data[1] = 20;//第二个元素
        data[2] = 30;//第三个元素
        for (int x = 0 ; x < data.length ; x++){
            System.out.println(data[x]);
        }

        //数组属于引用数据类型,在数组使用之前一定要开辟空间
        //如果没有开启空间的数组，在使用的时候
        int data_res[] = null;
//        System.out.println(data_res[x]);
    }


    //处理数组
    @Test
    public void testArrayDo() {
        //创建一个double数组
        double[] myList = {1.9, 2.9, 3.4, 3.5};
        //打印所有的数组元素
        //使用for循环进行打印
        for (int i = 0; i < myList.length; i++) {
            System.out.println(myList[i] + " ");
        }

        //计算所有元素的总和
        //声明一个接收总数的总和
        double total = 0;
        for (int i = 0; i < myList.length; i++) {
            total += myList[i];
        }
        System.out.println("Total is " + total);

        //查找最大的元素
        //初始化最大元素为第一个
        double max = myList[0];
        for (int i = 1; i < myList.length; i++) {
            if (myList[i] > max) max = myList[i];
        }
        System.out.println("Max is " + max);

        System.out.println("===========================");

        //增强for循环
        for (double ele : myList){
            //打印每个元素
            System.out.println(ele);
        }
    }

    //数组作为函数的参数
    public static void printArray(int[] array){
        for (int i = 0 ; i < array.length; i++){
            System.out.println(array[i] + " ");
        }
    }


    //数组作为函数的返回值
    //对数组进行翻转
    public static int[] reverse(int[] list){
        int[] result = new int[list.length];
        for(int i = 0 , j = result.length -1; i < list.length ; i++ , j--){
            result[j] = list[i];
        }
        //result数组作为函数的返回值
        return result;
    }

    @Test
    public void testArray02(){
//        printArray(new int[]{3 ,1 , 2 , 6 , 4 , 2});
        int[] reverse = reverse(new int[]{3, 1, 2, 6, 4, 2});
        for (Integer element : reverse){
            System.out.println(element);
        }
    }


    @Test
    public void testArray(){
        int[] arr_temp = new int[]{1,2,3,4,5,6,7,8,9,10};
        //这是Arrays工具类里面写好的方法，其实实现就是下面的逻辑,所以,只要掌握了基础
        //逻辑清晰，这些东西都是没问题的
        //用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，
        // 则返回搜索键的索引；否则返回 (-(插入点) - 1)。
        int i = Arrays.binarySearch(arr_temp, 8);
        System.out.println(i);
//        int i = binarySearch(arr_temp, 8);
//        System.out.println(i);
        //通过 equals 方法比较数组中元素值是否相等。
        //如果两个指定的 long 型数组彼此相等，则返回 true。
        // 如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，
        // 则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，
        // 则两个数组是相等的。
        // 同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
        int[] arr_temp1 = new int[]{1,2,3,4,5,6,7,8,9,10 , 11};
        System.out.println(Arrays.equals(arr_temp , arr_temp1));
    }

    //二分查找
    public static int binarySearch(int[] arr , int key){
        int low = 0;
        int high = arr.length - 1;
        while (low <= high){
            int mid = (low + high) / 2;
            if(arr[mid] < key){
                low = mid + 1;
            }else if(arr[mid] > key){
                high = mid - 1;
            }else if(arr[mid] == key){
                return mid;
            }
        }
        return -1;
    }



    @Test
    public void testFill(){
        int[] arr_temp = new int[11];
        //给数组赋值：通过 fill 方法。
        //将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
        //同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
        Arrays.fill(arr_temp , 1);
        for (int element : arr_temp){
            System.out.println(element);
        }
    }



    @Test
    public void testSort(){
        int[] arr_temp = new int[]{4,2,3,4,7,6,5,8,1,10};
        Arrays.sort(arr_temp);
        for (Integer element : arr_temp){
            System.out.println(element);
        }
    }


    @Test
    public void testSha1() throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("SHA-1");
        String data = "06zvdvxb";
        byte[] bytes = data.getBytes();
        digest.update(bytes);
        byte[] hashedBytes  = digest.digest();
        StringBuilder hexString = new StringBuilder();
        for(byte b : hashedBytes){
            String hex = Integer.toHexString(0xFF & b);
            if(hex.length() == 1){
                hexString.append(0);
            }
            hexString.append(hex);
        }
        String hashedData  = hexString.toString();
        System.out.println("加密结果:" + hashedData);
        //1678156b47e8105aef745158f3494acfce7bd59f
    }


    @Test
    public void testRandom(){
        Random random = new Random();
        int randomNumber = random.nextInt(900000) + 100000;
        System.out.println(randomNumber);
    }










}
